import json
import os
import time
from pathlib import Path
from typing import Dict, Any, List
import logging
from threading import Lock

logger = logging.getLogger(__name__)

class ConfigManager:
    """配置管理器，支持热加载"""
    
    def __init__(self):
        self.config_dir = Path(__file__).parent.parent / "config"
        self.country_mapping_file = self.config_dir / "country_mapping.json"
        self._country_mapping = {}  # 原始配置
        self._flat_mapping = {}     # 扁平化映射表，key为小写
        self._last_modified = {}
        self._lock = Lock()
        
        # 初始加载配置
        self._load_country_mapping()
    
    def _load_country_mapping(self):
        """加载国家映射配置并建立扁平化映射表"""
        try:
            if self.country_mapping_file.exists():
                with open(self.country_mapping_file, 'r', encoding='utf-8') as f:
                    data = json.load(f)
                    self._country_mapping = data.get('country_mapping', {})
                    self._last_modified['country_mapping'] = os.path.getmtime(self.country_mapping_file)
                    
                    # 建立扁平化映射表
                    self._build_flat_mapping()
                    
                    logger.info(f"加载国家映射配置: {len(self._country_mapping)} 个映射，{len(self._flat_mapping)} 个别名")
            else:
                logger.warning(f"国家映射配置文件不存在: {self.country_mapping_file}")
                self._country_mapping = {}
                self._flat_mapping = {}
        except Exception as e:
            logger.error(f"加载国家映射配置失败: {str(e)}")
            self._country_mapping = {}
            self._flat_mapping = {}
    
    def _build_flat_mapping(self):
        """建立扁平化映射表，所有key转为小写"""
        self._flat_mapping = {}
        
        for chinese_name, aliases in self._country_mapping.items():
            for alias in aliases:
                # 将所有别名转为小写作为key，中文名作为value
                key = alias.lower().strip()
                if key:
                    self._flat_mapping[key] = chinese_name
        
        logger.debug(f"建立扁平化映射表: {len(self._flat_mapping)} 个映射")
    
    def _check_and_reload_country_mapping(self):
        """检查并重新加载国家映射配置"""
        try:
            if not self.country_mapping_file.exists():
                return
            
            current_modified = os.path.getmtime(self.country_mapping_file)
            last_modified = self._last_modified.get('country_mapping', 0)
            
            if current_modified > last_modified:
                logger.info("检测到国家映射配置文件更新，重新加载...")
                self._load_country_mapping()
        except Exception as e:
            logger.error(f"检查国家映射配置文件失败: {str(e)}")
    
    def get_country_mapping(self) -> Dict[str, List[str]]:
        """获取国家映射配置（支持热加载）
        返回格式: {"中文名": ["English (Code)", "English", "中文名"]}
        """
        with self._lock:
            self._check_and_reload_country_mapping()
            return self._country_mapping.copy()
    
    def find_chinese_name(self, input_country: str) -> str:
        """根据输入的国家名称查找对应的中文名称
        
        Args:
            input_country: 输入的国家名称
            
        Returns:
            对应的中文名称，如果找不到则返回原值
        """
        if not input_country or not input_country.strip():
            return ""
        
        input_country = input_country.strip()
        
        with self._lock:
            self._check_and_reload_country_mapping()
            
            # 转为小写进行精确匹配
            key = input_country.lower()
            
            # 在扁平化映射表中查找
            if key in self._flat_mapping:
                return self._flat_mapping[key]
            
            # 如果没有找到匹配，返回原值
            return input_country
    
    def reload_all_configs(self):
        """手动重新加载所有配置"""
        with self._lock:
            logger.info("手动重新加载所有配置...")
            self._load_country_mapping()
    
    def add_country_mapping(self, chinese_name: str, aliases: List[str]):
        """动态添加国家映射"""
        with self._lock:
            if chinese_name not in self._country_mapping:
                self._country_mapping[chinese_name] = []
            
            # 添加新的别名，避免重复
            for alias in aliases:
                if alias not in self._country_mapping[chinese_name]:
                    self._country_mapping[chinese_name].append(alias)
            
            # 重新建立扁平化映射表
            self._build_flat_mapping()
            self._save_country_mapping()
    
    def remove_country_mapping(self, chinese_name: str):
        """动态删除国家映射"""
        with self._lock:
            if chinese_name in self._country_mapping:
                del self._country_mapping[chinese_name]
                # 重新建立扁平化映射表
                self._build_flat_mapping()
                self._save_country_mapping()

    def update_country_mapping(self, new_mapping: Dict[str, List[str]]):
        """更新整个国家映射配置"""
        with self._lock:
            # 验证输入格式
            if not isinstance(new_mapping, dict):
                raise ValueError("输入必须是字典格式")
            
            # 验证每个映射项
            for chinese_name, aliases in new_mapping.items():
                if not isinstance(aliases, list):
                    raise ValueError(f"国家 '{chinese_name}' 的映射必须是列表格式")
                for alias in aliases:
                    if not isinstance(alias, str):
                        raise ValueError(f"国家 '{chinese_name}' 的映射项必须是字符串")
            
            # 更新配置
            self._country_mapping = new_mapping.copy()
            
            # 重新建立扁平化映射表
            self._build_flat_mapping()
            
            # 保存到文件
            self._save_country_mapping()
            
            logger.info(f"国家映射配置已更新，共 {len(new_mapping)} 个国家")
    
    def _save_country_mapping(self):
        """保存国家映射配置到文件"""
        try:
            data = {"country_mapping": self._country_mapping}
            with open(self.country_mapping_file, 'w', encoding='utf-8') as f:
                json.dump(data, f, ensure_ascii=False, indent=2)
            self._last_modified['country_mapping'] = os.path.getmtime(self.country_mapping_file)
            logger.info("国家映射配置已保存")
        except Exception as e:
            logger.error(f"保存国家映射配置失败: {str(e)}")
    
    def get_flat_mapping_info(self) -> Dict[str, str]:
        """获取扁平化映射表信息（用于调试）"""
        with self._lock:
            self._check_and_reload_country_mapping()
            return self._flat_mapping.copy()

# 全局配置管理器实例
config_manager = ConfigManager()